import type { IMenu } from '../../pages/login/api/interface'
import type { IMenuCategory } from './types'
import { isInWhitelist } from './whitelist'

/**
 * 菜单核心处理模块
 * 包含菜单数据清洗、过滤、查找等核心功能
 */

/**
 * 清洗菜单数据，将原始菜单数据转换为层级结构
 * 处理三种类型的菜单：
 * 1. 父级菜单：没有 Url 的菜单项
 * 2. 子级菜单：有 Url 且有 ParentId 的菜单项
 * 3. 独立菜单：有 Url 但没有 ParentId 的菜单项（归类到"其他功能"）
 * @param menus 原始菜单数据
 * @returns 返回清洗后的菜单分类列表
 */
export const cleanMenuData = (menus: IMenu[]): IMenuCategory[] => {
  if (!menus || menus.length === 0) {
    return []
  }

  const result: IMenuCategory[] = []

  // 首先过滤掉ShowOnMenu为false的菜单
  const visibleMenus = menus.filter(menu => menu.ShowOnMenu)

  // 分离父级菜单和子级菜单
  const parentMenus = visibleMenus.filter(menu => !menu.Url) // 没有Url的是父级
  const childMenus = visibleMenus.filter(menu => menu.Url) // 有Url的是子级

  // 识别独立菜单项：有Url但没有ParentId的菜单
  const independentMenus = childMenus.filter(menu => !menu.ParentId)

  // 有ParentId的子级菜单
  const childMenusWithParent = childMenus.filter(menu => menu.ParentId)

  // 为每个父级菜单找到对应的子级菜单
  parentMenus.forEach(parent => {
    const children = childMenusWithParent.filter(child => child.ParentId === parent.Id)

    // 创建菜单分类
    const category: IMenuCategory = {
      category: parent,
      children: children
    }

    result.push(category)
  })

  // 如果有独立菜单项，创建"其他功能"分类
  if (independentMenus.length > 0) {
    const otherFunctionsCategory: IMenu = {
      Id: 'other-functions',
      Text: '其他功能',
      Icon: 'grid-outline',
      ShowOnMenu: true
      // 不设置 Url 和 ParentId
    }

    const category: IMenuCategory = {
      category: otherFunctionsCategory,
      children: independentMenus
    }

    result.push(category)
  }

  // 检查是否有孤立的子级菜单（有ParentId但没有对应父级的）
  const orphanMenus = childMenusWithParent.filter(child => {
    return !parentMenus.some(parent => parent.Id === child.ParentId)
  })

  if (orphanMenus.length > 0) {
    console.warn('发现孤立的子级菜单（没有对应父级）:', orphanMenus)
  }

  return result
}

/**
 * 获取扁平化的菜单列表（仅包含有Url且ShowOnMenu为true的菜单项）
 * @param menus 原始菜单数据
 * @returns 返回扁平化的菜单列表
 */
export const getFlatMenus = (menus: IMenu[]): IMenu[] => {
  if (!menus || menus.length === 0) {
    return []
  }

  return menus.filter(menu => menu.Url && menu.ShowOnMenu)
}

/**
 * 根据菜单ID查找菜单项（仅查找ShowOnMenu为true的菜单）
 * @param menus 原始菜单数据
 * @param menuId 菜单ID
 * @returns 返回找到的菜单项
 */
export const findMenuById = (menus: IMenu[], menuId: string): IMenu | undefined => {
  if (!menus || menus.length === 0) {
    return undefined
  }

  return menus.find(menu => menu.Id === menuId && menu.ShowOnMenu)
}

/**
 * 检查菜单项是否在白名单中
 * @param menu 菜单项
 * @returns 是否在白名单中
 */
export const isMenuInWhitelist = (menu: IMenu): boolean => {
  // 只检查文本名称是否在白名单中
  return isInWhitelist(menu.Text)
}

/**
 * 过滤菜单数据，只保留应用白名单中的功能模块
 * @param menuCategories 清洗后的菜单分类数据
 * @returns 返回过滤后的菜单分类列表
 */
export const filterMenusByWhitelist = (menuCategories: IMenuCategory[]): IMenuCategory[] => {
  if (!menuCategories || menuCategories.length === 0) {
    return []
  }

  return menuCategories.map(category => {
    // 过滤子菜单，只保留白名单中的应用
    const filteredChildren = category.children.filter(menu => {
      return isMenuInWhitelist(menu)
    })

    // 返回新的分类对象，保留分类名称，但只包含过滤后的子菜单
    return {
      category: category.category,
      children: filteredChildren
    }
  }).filter(category => {
    // 移除没有子菜单的分类
    return category.children.length > 0
  })
}

/**
 * 完整的菜单清洗和过滤流程
 * @param menus 原始菜单数据
 * @returns 返回清洗并过滤后的菜单分类列表
 */
export const processMenuData = (menus: IMenu[]): IMenuCategory[] => {
  // 1. 先进行基础清洗，转换为层级结构
  const menuCategories = cleanMenuData(menus)

  // 2. 然后过滤，只保留白名单中的应用
  const filteredCategories = filterMenusByWhitelist(menuCategories)

  return filteredCategories
}

/**
 * 根据分类ID查找菜单分类
 * @param menuCategories 菜单分类列表
 * @param categoryId 分类ID
 * @returns 返回找到的菜单分类
 */
export const findCategoryById = (menuCategories: IMenuCategory[], categoryId: string): IMenuCategory | undefined => {
  return menuCategories.find(category => category.category.Id === categoryId)
}

/**
 * 获取菜单统计信息
 * @param menus 原始菜单数据
 * @returns 返回菜单统计信息
 */
export const getMenuStats = (menus: IMenu[]) => {
  const flatMenus = getFlatMenus(menus)
  const menuCategories = cleanMenuData(menus)
  const filteredCategories = processMenuData(menus)

  // 首先过滤掉ShowOnMenu为false的菜单
  const visibleMenus = menus.filter(menu => menu.ShowOnMenu)

  // 统计独立菜单项（有Url但没有ParentId且ShowOnMenu为true的菜单）
  const independentMenus = visibleMenus.filter(menu => menu.Url && !menu.ParentId)

  return {
    totalMenus: menus.length,
    visibleMenus: visibleMenus.length,
    parentMenus: visibleMenus.filter(menu => !menu.Url).length,
    childMenus: flatMenus.length,
    independentMenus: independentMenus.length,
    categories: menuCategories.length,
    filteredCategories: filteredCategories.length,
    filteredMenus: filteredCategories.flatMap(cat => cat.children).length
  }
}
